home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_emacs.idb / usr / freeware / info / cl-6.z / cl-6
Encoding:
GNU Info File  |  1998-10-28  |  13.1 KB  |  251 lines
  1. This is Info file ../info/cl, produced by Makeinfo-1.64 from the input
  2. file cl.texi.
  3.  
  4.    This file documents the GNU Emacs Common Lisp emulation package.
  5.  
  6.    Copyright (C) 1993 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the section entitled "GNU General Public License" is included
  15. exactly as in the original, and provided that the entire resulting
  16. derived work is distributed under the terms of a permission notice
  17. identical to this one.
  18.  
  19.    Permission is granted to copy and distribute translations of this
  20. manual into another language, under the above conditions for modified
  21. versions, except that the section entitled "GNU General Public License"
  22. may be included in a translation approved by the author instead of in
  23. the original English.
  24.  
  25. 
  26. File: cl,  Node: Function Index,  Next: Variable Index,  Prev: Porting Common Lisp,  Up: Top
  27.  
  28. Function Index
  29. **************
  30.  
  31. * Menu:
  32.  
  33. * abs:                                  Numerical Functions.
  34. * acons:                                Association Lists.
  35. * adjoin:                               Lists as Sets.
  36. * assert:                               Assertions.
  37. * assoc*:                               Association Lists.
  38. * assoc-if:                             Association Lists.
  39. * assoc-if-not:                         Association Lists.
  40. * block:                                Blocks and Exits.
  41. * butlast:                              List Functions.
  42. * caddr:                                List Functions.
  43. * callf:                                Modify Macros.
  44. * callf2:                               Modify Macros.
  45. * case:                                 Conditionals.
  46. * ceiling*:                             Numerical Functions.
  47. * check-type:                           Assertions.
  48. * cl-float-limits:                      Implementation Parameters.
  49. * cl-prettyexpand:                      Efficiency Concerns.
  50. * clrhash:                              Hash Tables.
  51. * coerce:                               Type Predicates.
  52. * compiler-macroexpand:                 Macros.
  53. * concatenate:                          Sequence Functions.
  54. * copy-list:                            List Functions.
  55. * copy-tree:                            List Functions.
  56. * count:                                Searching Sequences.
  57. * count-if:                             Searching Sequences.
  58. * count-if-not:                         Searching Sequences.
  59. * decf:                                 Modify Macros.
  60. * declaim:                              Declarations.
  61. * declare:                              Declarations.
  62. * defalias:                             Function Aliases.
  63. * define-compiler-macro:                Macros.
  64. * define-modify-macro:                  Customizing Setf.
  65. * define-setf-method:                   Customizing Setf.
  66. * defmacro*:                            Argument Lists.
  67. * defsetf:                              Customizing Setf.
  68. * defstruct:                            Structures.
  69. * defsubst*:                            Argument Lists.
  70. * deftype:                              Type Predicates.
  71. * defun*:                               Argument Lists.
  72. * delete:                               Sequence Functions.
  73. * delete*:                              Sequence Functions.
  74. * delete-duplicates:                    Sequence Functions.
  75. * delete-if:                            Sequence Functions.
  76. * delete-if-not:                        Sequence Functions.
  77. * destructuring-bind:                   Macros.
  78. * do:                                   Iteration.
  79. * do*:                                  Iteration.
  80. * do-all-symbols:                       Iteration.
  81. * do-symbols:                           Iteration.
  82. * dolist:                               Iteration.
  83. * dotimes:                              Iteration.
  84. * ecase:                                Conditionals.
  85. * endp:                                 List Functions.
  86. * eql:                                  Equality Predicates.
  87. * equalp:                               Equality Predicates.
  88. * etypecase:                            Conditionals.
  89. * eval-when:                            Time of Evaluation.
  90. * eval-when-compile:                    Time of Evaluation.
  91. * evenp:                                Predicates on Numbers.
  92. * every:                                Mapping over Sequences.
  93. * expt:                                 Numerical Functions.
  94. * fill:                                 Sequence Functions.
  95. * find:                                 Searching Sequences.
  96. * find-if:                              Searching Sequences.
  97. * find-if-not:                          Searching Sequences.
  98. * first:                                List Functions.
  99. * flet:                                 Function Bindings.
  100. * floatp-safe:                          Predicates on Numbers.
  101. * floor*:                               Numerical Functions.
  102. * function*:                            Argument Lists.
  103. * gcd:                                  Numerical Functions.
  104. * gensym:                               Creating Symbols.
  105. * gentemp:                              Creating Symbols.
  106. * get*:                                 Property Lists.
  107. * get-setf-method:                      Customizing Setf.
  108. * getf:                                 Property Lists.
  109. * gethash:                              Hash Tables.
  110. * hash-table-count:                     Hash Tables.
  111. * hash-table-p:                         Hash Tables.
  112. * ignore-errors:                        Assertions.
  113. * incf:                                 Modify Macros.
  114. * intersection:                         Lists as Sets.
  115. * isqrt:                                Numerical Functions.
  116. * labels:                               Function Bindings.
  117. * last:                                 List Functions.
  118. * lcm:                                  Numerical Functions.
  119. * ldiff:                                List Functions.
  120. * letf:                                 Modify Macros.
  121. * letf*:                                Modify Macros.
  122. * lexical-let:                          Lexical Bindings.
  123. * lexical-let*:                         Lexical Bindings.
  124. * list*:                                List Functions.
  125. * list-length:                          List Functions.
  126. * load-time-value:                      Time of Evaluation.
  127. * locally:                              Declarations.
  128. * loop <1>:                             Iteration.
  129. * loop:                                 Loop Basics.
  130. * macrolet:                             Macro Bindings.
  131. * make-hash-table:                      Hash Tables.
  132. * make-random-state:                    Random Numbers.
  133. * map:                                  Mapping over Sequences.
  134. * mapc:                                 Mapping over Sequences.
  135. * mapcan:                               Mapping over Sequences.
  136. * mapcar*:                              Mapping over Sequences.
  137. * mapcon:                               Mapping over Sequences.
  138. * maphash:                              Hash Tables.
  139. * mapl:                                 Mapping over Sequences.
  140. * maplist:                              Mapping over Sequences.
  141. * member:                               Lists as Sets.
  142. * member*:                              Lists as Sets.
  143. * member-if:                            Lists as Sets.
  144. * member-if-not:                        Lists as Sets.
  145. * merge:                                Sorting Sequences.
  146. * minusp:                               Predicates on Numbers.
  147. * mismatch:                             Searching Sequences.
  148. * mod*:                                 Numerical Functions.
  149. * multiple-value-bind:                  Multiple Values.
  150. * multiple-value-setq:                  Multiple Values.
  151. * nbutlast:                             List Functions.
  152. * nintersection:                        Lists as Sets.
  153. * notany:                               Mapping over Sequences.
  154. * notevery:                             Mapping over Sequences.
  155. * nset-difference:                      Lists as Sets.
  156. * nset-exclusive-or:                    Lists as Sets.
  157. * nsublis:                              Substitution of Expressions.
  158. * nsubst:                               Substitution of Expressions.
  159. * nsubst-if:                            Substitution of Expressions.
  160. * nsubst-if-not:                        Substitution of Expressions.
  161. * nsubstitute:                          Sequence Functions.
  162. * nsubstitute-if:                       Sequence Functions.
  163. * nsubstitute-if-not:                   Sequence Functions.
  164. * nunion:                               Lists as Sets.
  165. * oddp:                                 Predicates on Numbers.
  166. * pairlis:                              Association Lists.
  167. * plusp:                                Predicates on Numbers.
  168. * pop:                                  Modify Macros.
  169. * position:                             Searching Sequences.
  170. * position-if:                          Searching Sequences.
  171. * position-if-not:                      Searching Sequences.
  172. * proclaim:                             Declarations.
  173. * progv:                                Dynamic Bindings.
  174. * psetf:                                Modify Macros.
  175. * psetq:                                Assignment.
  176. * push:                                 Modify Macros.
  177. * pushnew:                              Modify Macros.
  178. * random*:                              Random Numbers.
  179. * random-state-p:                       Random Numbers.
  180. * rassoc:                               Association Lists.
  181. * rassoc*:                              Association Lists.
  182. * rassoc-if:                            Association Lists.
  183. * rassoc-if-not:                        Association Lists.
  184. * reduce:                               Mapping over Sequences.
  185. * rem*:                                 Numerical Functions.
  186. * remf:                                 Property Lists.
  187. * remhash:                              Hash Tables.
  188. * remove:                               Sequence Functions.
  189. * remove*:                              Sequence Functions.
  190. * remove-duplicates:                    Sequence Functions.
  191. * remove-if:                            Sequence Functions.
  192. * remove-if-not:                        Sequence Functions.
  193. * remprop:                              Property Lists.
  194. * remq:                                 Sequence Functions.
  195. * replace:                              Sequence Functions.
  196. * rest:                                 List Functions.
  197. * return:                               Blocks and Exits.
  198. * return-from:                          Blocks and Exits.
  199. * rotatef:                              Modify Macros.
  200. * round*:                               Numerical Functions.
  201. * search:                               Searching Sequences.
  202. * set-difference:                       Lists as Sets.
  203. * set-exclusive-or:                     Lists as Sets.
  204. * setf:                                 Basic Setf.
  205. * shiftf:                               Modify Macros.
  206. * some:                                 Mapping over Sequences.
  207. * sort*:                                Sorting Sequences.
  208. * stable-sort:                          Sorting Sequences.
  209. * sublis:                               Substitution of Expressions.
  210. * subseq:                               Sequence Functions.
  211. * subsetp:                              Lists as Sets.
  212. * subst:                                Substitution of Expressions.
  213. * subst-if:                             Substitution of Expressions.
  214. * subst-if-not:                         Substitution of Expressions.
  215. * substitute:                           Sequence Functions.
  216. * substitute-if:                        Sequence Functions.
  217. * substitute-if-not:                    Sequence Functions.
  218. * symbol-macrolet:                      Macro Bindings.
  219. * tailp:                                Lists as Sets.
  220. * the:                                  Declarations.
  221. * tree-equal:                           List Functions.
  222. * truncate*:                            Numerical Functions.
  223. * typecase:                             Conditionals.
  224. * typep:                                Type Predicates.
  225. * union:                                Lists as Sets.
  226. * unless:                               Conditionals.
  227. * when:                                 Conditionals.
  228.  
  229. 
  230. File: cl,  Node: Variable Index,  Prev: Function Index,  Up: Top
  231.  
  232. Variable Index
  233. **************
  234.  
  235. * Menu:
  236.  
  237. * *gensym-counter*:                     Creating Symbols.
  238. * *random-state*:                       Random Numbers.
  239. * float-epsilon:                        Implementation Parameters.
  240. * float-negative-epsilon:               Implementation Parameters.
  241. * least-negative-float:                 Implementation Parameters.
  242. * least-negative-normalized-float:      Implementation Parameters.
  243. * least-positive-float:                 Implementation Parameters.
  244. * least-positive-normalized-float:      Implementation Parameters.
  245. * most-negative-fixnum:                 Implementation Parameters.
  246. * most-negative-float:                  Implementation Parameters.
  247. * most-positive-fixnum:                 Implementation Parameters.
  248. * most-positive-float:                  Implementation Parameters.
  249.  
  250.  
  251.